home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 12 / CU Amiga Magazine's Super CD-ROM 12 (1997)(EMAP Images)(GB)[!][issue 1997-07].iso / CUCD / Graphics / Gallery / Gallery.cpp < prev    next >
C/C++ Source or Header  |  1997-04-16  |  18KB  |  598 lines
  1. #define __VERSION__     "39"
  2. #define __REVISION__     "3"
  3. #define __NAME__            "Gallery"
  4. #define __AUTHOR__        "Markus Hillenbrand"
  5.  
  6. char *V = "$VER: " __NAME__ " " __VERSION__ "." __REVISION__ " (" __DATE__ ")";
  7.  
  8. #include <string.h>
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11.  
  12. #include <GUIC_Classes/GUIC_System.hpp>
  13. #include <GUIC_Classes/GUIC_Date.hpp>
  14. #include <GUIC_Classes/GUIC_Error.hpp>
  15. #include <GUIC_Classes/GUIC_Frame.hpp>
  16. #include <GUIC_Classes/GUIC_Application.hpp>
  17. #include <GUIC_Classes/GUIC_Screen.hpp>
  18. #include <GUIC_Classes/GUIC_Window.hpp>
  19. #include <GUIC_Classes/GUIC_Error.hpp>
  20. #include <GUIC_Classes/GUIC_Exceptions.hpp>
  21. #include <GUIC_Classes/GUIC_DirectoryExamine.hpp>
  22. #include <GUIC_Classes/GUIC_FileExamine.hpp>
  23. #include <GUIC_Classes/GUIC_File.hpp>
  24. #include <GUIC_Classes/GUIC_Key.hpp>
  25. #include <GUIC_Classes/GUIC_List.hpp>
  26. #include <GUIC_Classes/GUIC_Node.hpp>
  27. #include <GUIC_Classes/GUIC_Exceptions.hpp>
  28. #include <GUIC_Classes/GUIC_Button.hpp>
  29. #include <GUIC_Classes/GUIC_Checkbox.hpp>
  30. #include <GUIC_Classes/GUIC_String.hpp>
  31. #include <GUIC_Classes/GUIC_Integer.hpp>
  32. #include <GUIC_Classes/GUIC_Slider.hpp>
  33. #include <GUIC_Classes/GUIC_Label.hpp>
  34. #include <GUIC_Classes/GUIC_SlidingInteger.hpp>
  35. #include <GUIC_Classes/GUIC_FileString.hpp>
  36. #include <GUIC_Classes/GUIC_PathString.hpp>
  37. #include <GUIC_Classes/GUIC_Message.hpp>
  38. #include <GUIC_Classes/GUIC_FileRequester.hpp>
  39. #include <GUIC_Classes/GUIC_ProgramArgs.hpp>
  40.  
  41. #define COPYRIGHT    "<SMALL> index file created with 'Gallery', (c) 1997 by <A HREF=\"http://www.student.uni-kl.de/~hillenbr\">Markus Hillenbrand</A> </SMALL>"
  42. #define FILEFILTER     "#?.(jpeg|jpg|gif|iff|ilbm|iff24|png|bmp|pcx|tiff)"
  43.  
  44. #define MINLINES                    3
  45. #define MINCOLUMNS            3    
  46. #define MAXLINES                    200
  47. #define MAXCOLUMNS            200    
  48. #define DEFAULTLINES            3
  49. #define DEFAULTCOLUMNS    5
  50.  
  51. GUIC_ListC errorList;
  52. int lastDay=0,lastMonth=0,lastYear=0;
  53.  
  54.  
  55. class GalleryEntryC : public GUIC_ObjectC
  56.     {
  57.     public:
  58.         GalleryEntryC        (STRPTR f, LONG s, int d, int m, int y)     { fileName=f; size=s; day=d; month=m; year=y; }
  59.         int         compare    (GUIC_ObjectC &o);
  60.         void    print        (void) { cout << fileName << endl; }
  61.         String fileName;
  62.         int day,month,year;
  63.         LONG size;
  64.     protected:
  65.         void cleanUp(void) {};
  66.     };
  67.     
  68. int GalleryEntryC::compare(GUIC_ObjectC &o)
  69. { 
  70.     // First we must convert the argument to what it really is:
  71.     GalleryEntryC *g = (GalleryEntryC *)&o; 
  72.     
  73.     return strcmp(this->fileName, g->fileName); // Just compare the two file names    
  74. }
  75.  
  76. String     makeThumbnail    (GUIC_FileExamineC &file)
  77. {
  78.     String fileName = file.getName();
  79.  
  80.     int i = fileName.length();
  81.     while (--i) if (fileName[i] == '.') break;
  82.  
  83.     String thumbName = fileName.left(i);
  84.     thumbName+="_.jpg";
  85.  
  86.     try
  87.         {
  88.         GUIC_FileExamineC f(thumbName);
  89.         if (f.newer(file)) return thumbName;
  90.         }
  91.     catch (GUIC_SystemX &e) { }
  92.  
  93.     String args = "<>NIL: \"" + fileName + "\" TO \"" + thumbName + "\" FORMAT JPEG QUALITY 90 BOXFIT 100 100";
  94.  
  95.     cout << " - creating thumbnail for file '" << fileName << "' ... " << flush;
  96.     BOOL result = GUIC_SystemC::runProgram("GfxCon_68020", 100000, args);
  97.     if (result) cout << "done." << endl; else cout << "error occured." << endl;
  98.  
  99.     return thumbName;
  100. }
  101. void         createGallery        (GUIC_ListC &fileList, STRPTR pattern, LONG linesInTable, LONG columnsInTable, BOOL picClick)
  102. {
  103.     GalleryEntryC *key = (GalleryEntryC *)fileList.objectAt(1);
  104.     GUIC_FileExamineC firstFile(key->fileName);
  105.     String currentDir = firstFile.getPathPart();
  106.     
  107.     ldiv_t d = ldiv ( fileList.length(), columnsInTable );
  108.     int lines = d.quot;
  109.     if (d.rem) lines++;
  110.     
  111.     d = ldiv (lines, linesInTable);
  112.     int galleries = d.quot;
  113.     if (d.rem) galleries++;
  114.  
  115.     cout << "Creating " << galleries << " galleries in directory '" << currentDir << "' " << endl;
  116.     
  117.     fileList.sort();
  118.     
  119.     GUIC_FileExamineC directoryName(currentDir);
  120.  
  121.     // Create the index file with the frames
  122.     
  123.     GUIC_FileC gallery(currentDir, "index.html", GUIC_Write);
  124.     gallery.write("<TITLE>Gallery '");
  125.     gallery.write(directoryName.getFilePart());
  126.     gallery.writeLn("'</TITLE>");
  127.     gallery.writeLn("<FRAMESET COLS=150,*>");
  128.     gallery.writeLn("<FRAME NAME=F1 SRC=\"galleries.html\" MarginHeight=0 MarginWidth=0 Scrolling=\"auto\" FrameBorder=0>");
  129.     gallery.writeLn("<FRAME NAME=F2 SRC=\"index1.html\" MarginHeight=0 MarginWidth=0 Scrolling=\"auto\" FrameBorder=0>");
  130.     gallery.writeLn("</FRAMESET>");
  131.     
  132.     // now create the overview over the galleries
  133.     GUIC_FileC overview (currentDir, "galleries.html", GUIC_Write);
  134.     overview.writeLn("<HTML>");
  135.     overview.write("<H2>"); 
  136.     overview.write(directoryName.getFilePart());
  137.     overview.writeLn("</H2><BR>");
  138.     for (int i=1; i<=galleries; i++)
  139.         {
  140.         overview.write("<A HREF=\"index");
  141.         overview.write(i);
  142.         overview.write(".html\" TARGET=F2>Gallery ");
  143.         overview.write(i);
  144.         overview.writeLn("</A> <BR>");
  145.         }
  146.         
  147.     overview.writeLn("<BR> <BR> <IMG SRC=internal-gopher-menu> <A HREF=\"../index.html\" TARGET=_top> up </A>");
  148.     overview.writeLn("</HTML>");
  149.  
  150.     // create each gallery
  151.     int count = 0;
  152.     for (i=1; i<=galleries; i++)
  153.         {
  154.         char filename[256];
  155.         sprintf(filename, "index%ld.html", i);
  156.         GUIC_FileC indexFile(currentDir, filename, GUIC_Write);
  157.  
  158.         // write head and title    
  159.         indexFile.writeLn("<HTML>");
  160.         indexFile.writeLn("<HEAD>");
  161.     
  162.         indexFile.write("<TITLE> "); indexFile.write(directoryName.getFilePart());    indexFile.writeLn(" </TITLE>");
  163.         indexFile.writeLn("</HEAD>");
  164.         indexFile.write("<BODY");
  165.         if (pattern)
  166.             {
  167.             indexFile.write(" Background=\"");
  168.             indexFile.write(pattern);
  169.             indexFile.write("\"");
  170.             }
  171.         indexFile.writeLn(">");
  172.         
  173.         indexFile.write("<CENTER><H2>"); 
  174.         indexFile.write(directoryName.getFilePart()); 
  175.         indexFile.write("</H2> (Part ");
  176.         indexFile.write(i);
  177.         indexFile.write(" of ");
  178.         indexFile.write(galleries);
  179.         indexFile.writeLn(")<BR>");
  180.  
  181.         indexFile.writeLn("<HR>");
  182.         indexFile.writeLn("<TABLE Border=1 CellSpacing=4 CellPadding=4>");
  183.         
  184.         int boundary = count + columnsInTable*linesInTable;
  185.         if (boundary>fileList.length()) boundary = fileList.length();
  186.         
  187.         for (int j=count; j<boundary; j++)
  188.             {
  189.             key = (GalleryEntryC *)fileList.objectAt(j+1);
  190.             GUIC_FileExamineC file(key->fileName);
  191.             String thumbName = "";
  192.             
  193.             // Create the thumbnail now            
  194.             try
  195.                 {
  196.                 thumbName = makeThumbnail(file);
  197.                 GUIC_FileExamineC thumb (thumbName);
  198.                 thumbName = thumb.getFilePart();
  199.                 }
  200.             catch (GUIC_SystemX &e) { GalleryEntryC *s = new GalleryEntryC(key->fileName,0,0,0,0); errorList.addTail(*s); }
  201.  
  202.             // Check the date
  203.             GUIC_DateC oldDate(lastDay,lastMonth,lastYear),*fileDate = file.getDate();;
  204.             if (fileDate->greater(oldDate) )
  205.                 {
  206.                 lastDay   = fileDate->getDay();
  207.                 lastMonth = fileDate->getMonth();
  208.                 lastYear  = fileDate->getYear();
  209.                 }
  210.  
  211.             // Check if there are 5 entries per line in the table
  212.             if (count++ % columnsInTable == 0) indexFile.write("<TR> ");
  213.  
  214.             // write the picture data
  215.             indexFile.write("<TD> <CENTER>");
  216.             
  217.             if (picClick)
  218.                 {
  219.                 indexFile.write("<A HREF=\"");
  220.                 indexFile.write(file.getFilePart());
  221.                 indexFile.write("\"> <IMG SRC=\"");
  222.                 indexFile.write(thumbName);
  223.                 indexFile.write("\" ALT=Thumbnail> <BR>");
  224.                 }
  225.             else
  226.                 {
  227.                 indexFile.write("<IMG SRC=\"");
  228.                 indexFile.write(thumbName);
  229.                 indexFile.write("\" ALT=Thumbnail> <BR>");
  230.                 indexFile.write("<A HREF=\"");
  231.                 indexFile.write(file.getFilePart());
  232.                 indexFile.write("\">");
  233.                 }
  234.                 
  235.             indexFile.write(file.getFilePart());
  236.             indexFile.write(" </A> <BR> Size: ");
  237.             indexFile.write(key->size);
  238.             indexFile.write(" <BR> Date: ");
  239.             indexFile.write(key->day);
  240.             indexFile.write(".");
  241.             indexFile.write(key->month);
  242.             indexFile.write(".");
  243.             indexFile.write(key->year);
  244.             indexFile.writeLn("</TD>");
  245.             }
  246.             
  247.         indexFile.writeLn("</TABLE>");
  248.  
  249.         indexFile.writeLn("<HR>");
  250.         indexFile.writeLn(COPYRIGHT);
  251.         indexFile.writeLn("</BODY>");
  252.         indexFile.writeLn("</HTML>");
  253.         }
  254. }
  255. void         createHTML        (GUIC_ListC &fileList, STRPTR pattern)
  256. {
  257.     GalleryEntryC *key = (GalleryEntryC *)fileList.objectAt(1);
  258.     GUIC_FileExamineC firstFile(key->fileName);
  259.  
  260.     STRPTR currentDir = firstFile.getPathPart();
  261.     GUIC_FileC indexFile(currentDir, "index.html", GUIC_Write);
  262.     GUIC_FileExamineC directoryName(currentDir);
  263.  
  264.     String titleString = directoryName.getFilePart();
  265.     if (titleString == String("") ) titleString = directoryName.getName();
  266.  
  267.     cout << "Creating file '" << indexFile.getName() << "'" << endl;
  268.  
  269.     indexFile.writeLn("<HTML>");
  270.     indexFile.writeLn("<HEAD>");
  271.     indexFile.write("<TITLE> "); indexFile.write(titleString); indexFile.writeLn(" </TITLE>");
  272.     indexFile.writeLn("</HEAD>");
  273.     indexFile.write("<BODY");
  274.     if (pattern)
  275.         {
  276.         indexFile.write(" Background=\"");
  277.         indexFile.write(pattern);
  278.         indexFile.write("\"");
  279.         }
  280.     indexFile.writeLn(">");
  281.     indexFile.write("<CENTER><H1>"); indexFile.write(titleString); indexFile.writeLn("</H1>");
  282.     indexFile.writeLn("<HR><BR><BR>");
  283.     
  284.     // Create the table of galleries
  285.     
  286.     indexFile.writeLn("<TABLE Border=1 CellSpacing=4 CellPadding=4>");
  287.     indexFile.writeLn("<TR> <TH> <CENTER> <H3> Gallery Name </H3> </TH> <TH> <CENTER> <H3> Entries </H3> </TH> <TH> <CENTER> <H3> Last Update </H3> </TH>");
  288.     
  289.     fileList.sort();
  290.     
  291.     for (int i=1; i<=fileList.length(); i++)
  292.         {
  293.         key = (GalleryEntryC *)fileList.objectAt(i);
  294.         GUIC_FileExamineC file (key->fileName);
  295.  
  296.         indexFile.write("<TR> <TD> <CENTER> <A HREF=\"");
  297.         indexFile.write(file.getFilePart());
  298.         indexFile.write("/index.html\"");
  299.         indexFile.write("> ");
  300.         indexFile.write(file.getFilePart());
  301.         indexFile.write(" </A> </TD> <TD> <CENTER> ");
  302.         indexFile.write(key->size);
  303.         indexFile.write(" </TD> <TD> <CENTER> ");
  304.  
  305.         if (key->day)
  306.             {
  307.             indexFile.write(key->day);
  308.             indexFile.write(".");
  309.             indexFile.write(key->month);
  310.             indexFile.write(".");
  311.             indexFile.write(key->year);
  312.             }
  313.         else indexFile.write("(Directory)");
  314.         indexFile.writeLn(" </TD>");
  315.         }
  316.  
  317.     indexFile.writeLn("</TABLE>");
  318.  
  319.     indexFile.writeLn("<BR> <IMG SRC=internal-gopher-menu> <A HREF=\"../index.html\" TARGET=_top> up </A> <BR>");
  320.  
  321.     indexFile.writeLn("<HR>");
  322.     indexFile.writeLn(COPYRIGHT);
  323.     indexFile.writeLn("</BODY>");
  324.     indexFile.writeLn("</HTML>");
  325. }
  326. int             scanDir                (STRPTR startDir, STRPTR pattern, LONG linesInTable, LONG columnsInTable, BOOL picClick)
  327. {
  328.     GUIC_ListC fileList,dirList;
  329.     GalleryEntryC *key = 0;
  330.     GUIC_FileExamineC *filex = 0;
  331.     int entries = 0;
  332.  
  333.     GUIC_FileExamineC *examine = new GUIC_FileExamineC(startDir);
  334.     if (!examine->isDirectory()) throw GUIC_SystemX("Error in function ScanDir (directory name expected).");
  335.     String dirName = examine->getName();
  336.     delete examine; examine=0;
  337.  
  338.     GUIC_DirectoryExamineC *direx= new GUIC_DirectoryExamineC(dirName);
  339.     BOOL hasSubDirs = direx->hasSubdirectory();
  340.     if (!hasSubDirs) direx->setFilter(FILEFILTER);
  341.  
  342.     try
  343.         {
  344.         while ( (filex = direx->examineNext()) )
  345.             {
  346.             String fileName  = filex->getName();
  347.             GUIC_DateC *date = filex->getDate();
  348.  
  349.             if (filex->isDirectory())
  350.                 {
  351.                 String newPattern = String("../") + String(pattern);
  352.                 int entriesInDir  = scanDir(fileName, pattern ? (STRPTR) newPattern : 0, linesInTable, columnsInTable, picClick);
  353.                 if (entriesInDir)
  354.                     {
  355.                     key = new GalleryEntryC(fileName, entriesInDir, lastDay, lastMonth, lastYear);
  356.                     if (!key) throw GUIC_MemoryX("Can't allocate memory for key.");
  357.                     dirList.addTail(*key);
  358.                     entries+=entriesInDir;
  359.                     }
  360.                 lastDay=0; lastMonth=0; lastYear=0;
  361.                 }
  362.             else if (! hasSubDirs && (fileName.right(5) != String("_.jpg") ) )
  363.                 {
  364.                 key = new GalleryEntryC(fileName, filex->getSize(), date->getDay(), date->getMonth(), date->getYear() );
  365.                 if (!key) throw GUIC_MemoryX("Can't allocate memory for key.");
  366.                 fileList.addTail(*key);
  367.                 entries++;
  368.                 }
  369.             }
  370.         }
  371.     catch (GUIC_SystemX &e) { cerr << "Exception caught while processing directory '" << direx->getName() << "': " << e.getMessage() << endl; }
  372.     delete direx;direx=0; /* Damit der lock auf das Verzeichnis freigegeben wird ! */
  373.  
  374.     if (dirList.length())     createHTML        (dirList,pattern);
  375.     if (fileList.length())    createGallery        (fileList,pattern, linesInTable, columnsInTable, picClick);
  376.  
  377.     while (fileList.length()) delete (GalleryEntryC *)fileList.remove(1);
  378.     while ( dirList.length()) delete (GalleryEntryC *) dirList.remove(1);
  379.  
  380.     return entries;
  381. }
  382.  
  383.  
  384. class GalleryWindowC : public GUIC_WindowC
  385.     {
  386.     public:
  387.         GalleryWindowC    (GUIC_ApplicationC *app, GUIC_ScreenC *screen);
  388.         ~GalleryWindowC (void);
  389.         BOOL action        (GUIC_EventC &);
  390.     private:
  391.         GUIC_ButtonC                *start, *quit;
  392.         GUIC_FileStringC            *pattern;
  393.         GUIC_PathStringC        *directory;
  394.         GUIC_SlidingIntegerC     *lines, *columns;
  395.         GUIC_FrameC                *frame;
  396.         GUIC_CheckboxC        *click;
  397.         GUIC_LabelC                *dirLabel, *pattLabel, *linesLabel, *columnsLabel, *clickLabel;
  398.     };
  399.     
  400. GalleryWindowC::GalleryWindowC    (GUIC_ApplicationC *app, GUIC_ScreenC *screen) : GUIC_WindowC (-1,-1,46,19)
  401. {
  402.     frame                = new GUIC_FrameC                (1,1,44,14,"Gallery");
  403.  
  404.     dirLabel            = new GUIC_LabelC                (3, 2,10,2,"_Directory:");
  405.     pattLabel        = new GUIC_LabelC                (3, 4,10,2,"_Pattern:");
  406.     linesLabel        = new GUIC_LabelC                (3, 7,10,2,"_Lines:");
  407.     columnsLabel    = new GUIC_LabelC                (3, 9,10,2,"_Columns:");
  408.     clickLabel        = new GUIC_LabelC                (3,12,30,2,"Use _thumbnail picture as link:");
  409.  
  410.     directory            = new GUIC_PathStringC        (13, 2,30,2,"");
  411.     pattern            = new GUIC_FileStringC            (13, 4,30,2,"");
  412.     lines                = new GUIC_SlidingIntegerC    (13, 7,30,2,MINLINES,MAXLINES,DEFAULTLINES);
  413.     columns            = new GUIC_SlidingIntegerC    (13, 9,30,2,MINCOLUMNS,MAXCOLUMNS,DEFAULTCOLUMNS);    
  414.     click                = new GUIC_CheckboxC            (40,12, 3,2,FALSE);
  415.     
  416.     start                = new GUIC_ButtonC                (1,16,15,2,"_Start");
  417.     quit                    = new GUIC_ButtonC                (30,16,15,2,"_Quit");
  418.     
  419.     directory    ->setHelp("Directory for the first index file.");
  420.     pattern    ->setHelp("Background pattern in HTML pages.");
  421.     lines        ->setHelp("The number of lines per HTML table.");
  422.     columns    ->setHelp("The number of columns per HTML table.");
  423.     click        ->setHelp("Click on thumbnails to view picture?");
  424.     start        ->setHelp("Start the creation of the gallery.");
  425.     quit            ->setHelp("Quit the program.");
  426.     
  427.     directory    ->setShortcut('d');
  428.     pattern    ->setShortcut('p');
  429.     lines        ->setShortcut('l');
  430.     columns    ->setShortcut('c');
  431.     click        ->setShortcut('t');
  432.     start        ->setShortcut('s');
  433.     quit            ->setShortcut('q');
  434.     
  435.     add(frame);
  436.     add(dirLabel);
  437.     add(directory);
  438.     add(pattLabel);
  439.     add(pattern);
  440.     add(linesLabel);
  441.     add(lines);
  442.     add(columnsLabel);
  443.     add(columns);
  444.     add(clickLabel);
  445.     add(click);
  446.     add(start);
  447.     add(quit);
  448.     
  449.     app->addPrefs("GalleryWindow"            , this);
  450.     app->addPrefs("StartDirectory"            , directory);
  451.     app->addPrefs("BackgroundPattern"    , pattern);
  452.     app->addPrefs("NumberOfLines"            , lines);
  453.     app->addPrefs("PictureAsLink"                , click);
  454.     app->addPrefs("NumberOfColumns"        , columns);
  455.  
  456.     setTitle("Gallery - (c) by Markus Hillenbrand");
  457.     setHelp(TRUE);
  458.     activate();
  459. }
  460. GalleryWindowC::~GalleryWindowC    (void)
  461. {
  462.     delete frame;
  463.     delete dirLabel;
  464.     delete directory;
  465.     delete pattLabel;
  466.     delete pattern;
  467.     delete linesLabel;
  468.     delete lines;
  469.     delete columnsLabel;
  470.     delete columns;
  471.     delete clickLabel;
  472.     delete click;
  473.     delete start;
  474.     delete quit;
  475. }
  476.  
  477. BOOL GalleryWindowC::action(GUIC_EventC &e)
  478. {
  479.     switch (e.id)
  480.         {
  481.         case GUIC_GadgetEvent:
  482.             if (e.gadget == (GUIC_GadgetC *)start)
  483.                 {
  484.                 if (! strcmp(directory->get(), "") )
  485.                     {
  486.                     GUIC_ErrorC e("You must at least enter a directory name!");
  487.                     e.request(this);
  488.                     }
  489.                 else 
  490.                     {
  491.                     GUIC_SystemC::openConsole();
  492.                     sleep();
  493.                     activate();
  494.                     try 
  495.                         {
  496.                         scanDir (directory->get(), pattern->get(), lines->get(), columns->get(), click->get() );
  497.                         }
  498.                     catch (GUIC_Exception &x) { GUIC_ErrorC e("Exception caught:", x.getMessage() ); e.request(this); }
  499.                     waken();
  500.                     }
  501.                 }
  502.             else if (e.gadget == (GUIC_GadgetC *)quit) 
  503.                 {
  504.                 dispose();
  505.                 }
  506.             return TRUE;
  507.             break;
  508.         case GUIC_CloseWindow: 
  509.             return TRUE;
  510.             break;
  511.         default:
  512.             cerr << "Got an event: " << e.id << endl;
  513.         }
  514.     
  515.     return FALSE;
  516. }
  517.  
  518.  
  519.  
  520. void         shell                    (void)
  521. {
  522.     LONG result[] = { 0,0,0,0,0 };
  523.     STRPTR templ = "STARTDIR/A,LINES/N,COLUMNS/N,BGPATTERN,PICCLICK/S";
  524.     GUIC_ProgramArgsC args;
  525.     if (! args.fit(templ, result))
  526.         {
  527.         cerr << "Usage: " << templ << endl;
  528.         GUIC_SystemC::exit(GUIC_ExitError);
  529.         }
  530.     
  531.     LONG lines = result[1] ? *(LONG *)result[1] : DEFAULTLINES;
  532.     if (lines < MINLINES)         lines=MINLINES;
  533.     if (lines > MAXLINES)    lines=MAXLINES;
  534.     
  535.     LONG columns = result[2] ? *(LONG *)result[2] : DEFAULTCOLUMNS;
  536.     if (columns < MINCOLUMNS)     columns=MINCOLUMNS;
  537.     if (columns > MAXCOLUMNS)    columns=MAXCOLUMNS;
  538.     
  539.     BOOL picclick = result[4];
  540.     
  541.     scanDir((STRPTR)result[0], (STRPTR)result[3], lines, columns, picclick); 
  542.  
  543.     if (errorList.length())
  544.         {
  545.         cerr << "The following files could not be converted to a thumbnail:" << endl;
  546.         while (errorList.length())
  547.             {
  548.             GalleryEntryC *s = (GalleryEntryC *)errorList.remove(1);
  549.             cerr << "- " << s->fileName << endl;
  550.             delete s;
  551.             }
  552.         cerr << "Please check them and run 'Gallery' again." << endl;
  553.         }
  554. }
  555. void        workbench            (void)
  556. {
  557.     GUIC_ApplicationC    app("Gallery");
  558.  
  559.     app.setAuthor        (__AUTHOR__);
  560.     app.setVersion    (__VERSION__);
  561.     app.setRevision    (__REVISION__);
  562.     app.setDate        (__DATE__);
  563.     app.setTime        (__TIME__);
  564.     app.setInitializer    (TRUE);
  565.  
  566.     GUIC_ScreenC            screen;
  567.     GalleryWindowC     window(&app, &screen);
  568.     
  569.     screen.add(window);
  570.     app.add(screen);
  571.  
  572.     app.start();
  573.  
  574.     BOOL running = TRUE;
  575.     GUIC_EventC *event = 0;
  576.  
  577.     int count = 0;
  578.     
  579.     while (running && (event = app.wait()) )
  580.         {
  581.         // As we have only one window, it is not neccessary to check for the window id
  582.         if (event->id == GUIC_CloseWindow) 
  583.             {
  584.             GUIC_MessageC    message    ("Do you really want to quit ?", "Yes|No");
  585.             if (1 == message.request(*event->window)) running = FALSE;
  586.             }
  587.         }
  588.  
  589.     app.stop();
  590. }
  591.  
  592. void         main                    (int argc, char **argv)
  593. {
  594.     GUIC_SystemC::checkStackSize(50000);
  595.     if (GUIC_SystemC::runFromShell() ) shell(); else workbench();
  596. }
  597.  
  598.